package com.gxc.string;

import java.util.*;

/**
 * 斗地主起源于湖北十堰房县，据说是一位叫吴修全的年轻人根据当地流行的扑克玩法“跑得快”改编的，如今已风靡整个中国，并流行于互联网上。
 *
 * 牌型：单顺，又称顺子，最少5张牌，最多12张牌(3…A)不能有2，也不能有大小王，不计花色。
 *
 * 例如： 3-4-5-6-7-8，7-8-9-10-J-Q，3-4-5-6-7-8-9-10-J-Q-K-A
 *
 * 可用的牌 3<4<5<6<7<8<9<10<J<Q<K<A<2<B(小王)<C(大王)，每种牌除大小王外有四种花色
 *
 * (共有13×4+2张牌)
 *
 * 输入：
 *
 * 手上有的牌
 * 已经出过的牌(包括对手出的和自己出的牌)
 * 输出：
 *
 * 对手可能构成的最长的顺子(如果有相同长度的顺子，输出牌面最大的那一个)，
 * 如果无法构成顺子，则输出 NO-CHAIN。
 * 输入描述
 * 输入的第一行为当前手中的牌
 *
 * 输入的第二行为已经出过的牌
 *
 * 输出描述
 * 最长的顺子
 */
public class DouDiZhu {

    public static void main3(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String[] hand = scanner.nextLine().split("-");
        String[] used = scanner.nextLine().split("-");
        scanner.close();

        int[] array = new int[12];
        Map<String, java.lang.Integer> rel = new HashMap<>();
        rel.put("3", 0);
        rel.put("4", 1);
        rel.put("5", 2);
        rel.put("6", 3);
        rel.put("7", 4);
        rel.put("8", 5);
        rel.put("9", 6);
        rel.put("10", 7);
        rel.put("J", 8);
        rel.put("Q", 9);
        rel.put("K", 10);
        rel.put("A", 11);

        Map<java.lang.Integer, String> rel2 = new HashMap<>();
        rel2.put(0, "3");
        rel2.put(1, "4");
        rel2.put(2, "5");
        rel2.put(3, "6");
        rel2.put(4, "7");
        rel2.put(5, "8");
        rel2.put(6, "9");
        rel2.put(7, "10");
        rel2.put(8, "J");
        rel2.put(9, "Q");
        rel2.put(10, "K");
        rel2.put(11, "A");
        for (int i = 0; i < hand.length; i++) {
            String s = hand[i];
            java.lang.Integer index = rel.get(s);
            if (index!=null) array[index]++;
        }
        for (int i = 0; i < used.length; i++) {
            String s = used[i];
            java.lang.Integer index = rel.get(s);
            if (index!=null) array[index]++;
        }

        int continuous = 0;
        int max = 4;
        int start = -1;
        for (int i = array.length - 1; i >= 0; i--) {
            if (array[i]<4) {
                continuous++;
                if (continuous>max) {
                    max = continuous;
                    start = i;
                }
            } else {
                continuous = 0;
            }
        }
        if (start == -1) {
            System.out.println("NO-CHAIN");
        } else {
            for (int i = start; i < start + max; i++) {
                System.out.print(rel2.get(i));
                if (i!=start+max-1) System.out.print("-");
            }
        }
    }

    // Java 中的 split 方法，使用正则处理
    public static List<String> split(String str, String delimiter) {
        return Arrays.asList(str.split(delimiter));
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // 读取输入
        String my = scanner.nextLine();
        String used = scanner.nextLine();
        scanner.close();

        // 定义牌的初始数量
        Map<String, java.lang.Integer> deckCount = new HashMap<>();
        Map<String, java.lang.Integer> deckValue = new HashMap<>();
        List<String> cardSequence = Arrays.asList("3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2", "B", "C");

        // 初始化牌的数量
        for (String card : cardSequence) {
            deckCount.put(card, 4);
        }
        deckCount.put("B", 1);
        deckCount.put("C", 1);

        // 初始化牌的值
        int value = 3;
        for (String card : cardSequence) {
            deckValue.put(card, value++);
        }
        deckValue.put("2", 16);
        deckValue.put("B", 17);
        deckValue.put("C", 18);

        // 处理手上的牌和已经出的牌
        for (String card : split(my, "-")) {
            deckCount.put(card, deckCount.get(card) - 1);
        }
        for (String card : split(used, "-")) {
            deckCount.put(card, deckCount.get(card) - 1);
        }

        // 获取剩余牌并按顺序存储
        List<String> cards = new ArrayList<>();
        for (String card : cardSequence) {
            int count = deckCount.get(card);
            for (int i = 0; i < count; i++) {
                cards.add(card);
            }
        }

        // 计算最长顺子
        List<List<String>> res = new ArrayList<>();
        if (!cards.isEmpty()) {
            List<String> tmp = new ArrayList<>();
            tmp.add(cards.get(0));
            res.add(tmp);
        }

        for (int i = 1; i < cards.size(); i++) {
            boolean isMatch = false;
            for (List<String> tmp : res) {
                if (deckValue.get(cards.get(i)) - deckValue.get(tmp.get(tmp.size() - 1)) == 1) {
                    isMatch = true;
                    tmp.add(cards.get(i));
                    break;
                }
            }
            if (!isMatch) {
                List<String> newItem = new ArrayList<>();
                newItem.add(cards.get(i));
                res.add(newItem);
            }
        }

        // 查找最长顺子
        List<String> longest = null;
        for (List<String> tmp : res) {
            if (tmp.size() >= 5 && (longest == null || tmp.size() >= longest.size())) {
                longest = tmp;
            }
        }

        // 输出结果
        if (longest == null) {
            System.out.println("NO-CHAIN");
        } else {
            System.out.println(String.join("-", longest));
        }
    }
}
